1:

require 'cocoapods-core/source/acceptor'

2:

require 'cocoapods-core/source/aggregate'

3:

require 'cocoapods-core/source/health_reporter'

4:

5:

module Pod

6:

7:

  # The Source class is responsible to manage a collection of podspecs.

8:

9:

  # The backing store of the podspecs collection is an implementation detail

10:

  # abstracted from the rest of CocoaPods.

11:

12:

  # The default implementation uses a git repo as a backing store, where the

13:

  # podspecs are namespaced as:

14:

15:

  #     "#{SPEC_NAME}/#{VERSION}/#{SPEC_NAME}.podspec"

16:

17:

  class Source

18:

19:

    # @return [Pathname] the location of the repo of the source.

20:

21:

    attr_reader :repo

22:

23:

    # @param  [Pathname, String] repo @see #repo.

24:

25:

    def initialize(repo)

26:

      @repo = Pathname.new(repo)

27:

end

28:

29:

    # @return [String] the name of the source.

30:

31:

    def name

32:

      repo.basename.to_s

33:

end

34:

35:

    alias_method :to_s, :name

36:

37:

38:

    # @return [Integer] compares a source with another one for sorting

39:

    #         purposes.

40:

41:

    # @note   Source are compared by the alphabetical order of their name, and

42:

    #         this convention should be used in any case where sources need to

43:

    #         be disambiguated.

44:

45:

    def <=> (other)

46:

      name <=> other.name

47:

end

48:

49:

    #-------------------------------------------------------------------------#

50:

51:

    # @!group Queering the source

52:

53:

    # @return [Array] the list of the name of all the Pods.

54:

55:

    # @note   Using Pathname#children is sensibly slower.

56:

57:

    def pods

58:

      specs_dir_as_string = specs_dir.to_s

59:

      Dir.entries(specs_dir).select do |entry|

60:

        valid_name = !(entry =='.' || entry == '..' || entry == '.git')

61:

        valid_name && File.directory?(File.join(specs_dir_as_string, entry))

62:

end

63:

end

64:

65:

    # Returns the set for the Pod with the given name.

66:

67:

    # @param  [String] pod_name

68:

    #         The name of the Pod.

69:

70:

    # @return [Sets] the set.

71:

72:

    def set(pod_name)

73:

      Specification::Set.new(pod_name, self)

74:

end

75:

76:

    # @return [Array] the sets of all the Pods.

77:

78:

    def pod_sets

79:

      pods.map { |pod_name| set(pod_name) }

80:

end

81:

82:

    # @return [Array] all the available versions for the Pod, sorted

83:

    #         from highest to lowest.

84:

85:

    # @param  [String] name

86:

    #         the name of the Pod.

87:

88:

    def versions(name)

89:

      pod_dir = specs_dir + name

90:

      return unless pod_dir.exist?

91:

      pod_dir.children.map do |v|

92:

        basename = v.basename.to_s

93:

        Version.new(basename) if v.directory? && basename[0,1] != '.'

94:

      end.compact.sort.reverse

95:

end

96:

97:

    # @return [Specification] the specification for a given version of Pod.

98:

99:

    # @param  @see specification_path

100:

101:

    def specification(name, version)

102:

      Specification.from_file(specification_path(name, version))

103:

end

104:

105:

    # Returns the path of the specification with the given name and version.

106:

107:

    # @param  [String] name

108:

    #         the name of the Pod.

109:

110:

    # @param  [Version,String] version

111:

    #         the version for the specification.

112:

113:

    # @return [Pathname] The path of the specification.

114:

115:

    def specification_path(name, version)

116:

      path = specs_dir + name + version.to_s

117:

118:

      unless specification_path.exist?

119:

120:

end

121:

      unless specification_path.exist?

122:

        raise StandardError, "Unable to find the specification #{name} " \

123:

          "(#{version}) in the #{name} source."

124:

end

125:

      specification_path

126:

end

127:

128:

    # @return [Array] all the specifications contained by the

129:

    #         source.

130:

131:

    def all_specs

132:

      specs = pods.map do |name|

133:

        begin

134:

          versions(name).map { |version| specification(name, version) }

135:

        rescue

136:

          CoreUI.warn "Skipping `#{name}` because the podspec contains errors."

137:

          next

138:

end

139:

end

140:

      specs.flatten.compact

141:

end

142:

143:

    #-------------------------------------------------------------------------#

144:

145:

    # @!group Searching the source

146:

147:

    # @return [Set] a set for a given dependency. The set is identified by the

148:

    #               name of the dependency and takes into account subspecs.

149:

150:

    def search(dependency)

151:

      pod_sets.find do |set|

152:

        # First match the (top level) name, which does not yet load the spec from disk

153:

        set.name == dependency.root_name &&

154:

          # Now either check if it's a dependency on the top level spec, or if it's not

155:

          # check if the requested subspec exists in the top level spec.

156:

          set.specification.subspec_by_name(dependency.name)

157:

end

158:

end

159:

160:

    # @return [Array] The list of the sets that contain the search term.

161:

162:

    # @param  [String] query

163:

    #         the search term.

164:

165:

    # @param  [Bool] full_text_search

166:

    #         whether the search should be limited to the name of the Pod or

167:

    #         should include also the author, the summary, and the description.

168:

169:

    # @note   full text search requires to load the specification for each pod,

170:

    #         hence is considerably slower.

171:

172:

    def search_by_name(query, full_text_search = false)

173:

      if full_text_search

174:

        pod_sets.map do |set|

175:

          begin

176:

            s = set.specification

177:

            text = "#{s.name} #{s.authors} #{s.summary} #{s.description}"

178:

          rescue

179:

            CoreUI.warn "Skipping `#{set.name}` because the podspec contains errors."

180:

end

181:

          set if text && text.downcase.include?(query.downcase)

182:

        end.compact

183:

      else

184:

        names = pods.select { |pod_name| pod_name.downcase.include?(query.downcase) }

185:

        names.map { |pod_name| set(pod_name) }

186:

end

187:

end

188:

189:

    #-------------------------------------------------------------------------#

190:

191:

    # @!group Representations

192:

193:

    # @return [Hash{String=>{String=>Specification}}] the static representation

194:

    #         of all the specifications grouped first by name and then by

195:

    #         version.

196:

197:

    def to_hash

198:

      hash = {}

199:

      all_specs.each do |spec|

200:

        hash[spec.name] ||= {}

201:

        hash[spec.name][spec.version.version] = spec.to_hash

202:

end

203:

      hash

204:

end

205:

206:

    # @return [String] the YAML encoded {to_hash} representation.

207:

208:

    def to_yaml

209:

      require 'yaml'

210:

      to_hash.to_yaml

211:

end

212:

213:

    private

214:

215:

    #-------------------------------------------------------------------------#

216:

217:

    # @group Private Helpers

218:

219:

    # @return [Pathname] The directory where the specs are stored.

220:

221:

    # @note   In previous versions of CocoaPods they used to be stored in

222:

    #         the root of the repo. This lead to issues, especially with

223:

    #         the GitHub interface and now the are stored in a dedicated

224:

    #         folder.

225:

226:

    def specs_dir

227:

      unless @specs_dir

228:

        specs_sub_dir = repo + 'Specs'

229:

        if specs_sub_dir.exist?

230:

          @specs_dir = specs_sub_dir

231:

        else

232:

          @specs_dir = repo

233:

end

234:

end

235:

      @specs_dir

236:

end

237:

238:

    #-------------------------------------------------------------------------#

239:

240:

end

241:

end